home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / cross.com / CROSS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-23  |  30.6 KB  |  889 lines
  1. /***********************************************************/
  2. /*                                                         */
  3. /*    CROSS  -  A 'C' Cross refernce Utility               */
  4. /*                                                         */
  5. /*    Version 1.0   January, 1982                          */
  6. /*                                                         */
  7. /*    Copyright (c) 1982 by Philip N. Hisley               */
  8. /*                                                         */
  9. /*    Released for non-commercial distribution only        */
  10. /*                                                         */
  11. /*    Abstract:                                            */
  12. /*                                                         */
  13. /*    'CROSS' is a cross-reference utility for 'C' programs*/
  14. /*    Its has the ability to handle nested include files   */
  15. /*    to a depth of 8 levels and properly processes nested */
  16. /*    comments as supported by BDS C. Option flags support */
  17. /*    the following features:                              */
  18. /*                                                         */
  19. /*    - Routing of list output to disk                     */
  20. /*    - Cross-referencing of reserved words                */
  21. /*    - Processing of nested include files                 */
  22. /*    - Generation of listing only                         */
  23. /*                                                         */
  24. /*    Usage: cross  <flag(s)> <filename>                   */
  25. /*                                                         */
  26. /*    Flags: -i            = Enable file inclusion         */
  27. /*           -c            = Cross reference only          */
  28. /*           -l            = Generate listing only         */
  29. /*           -p            = Reset page size (Def:60)      */
  30. /*           -r            = Cross-ref reserved words      */
  31. /*           -o<filename>  = Write output to named file    */
  32. /*                                                         */
  33. /*    -------------------------------------------------    */
  34. /*                                                         */
  35. /*    Modified for Lattice 'C' Version 1.01                */
  36. /*    By: John W. Kindschi Jr.  16 Nov 1983                */
  37. /*                                                         */
  38. /*                                                         */
  39. /*    Modified for Turbo 'C' and Unix                      */
  40. /*    Added -c option for references only                  */
  41. /*    Fixed -i option - no abort if not found              */
  42. /*    Rebuilt command line interpreter                     */
  43. /*    Print message when include file not found            */
  44. /*    Default output to a.crf                              */
  45. /*    Allowed variable page size settings                  */
  46. /*                                                         */
  47. /*    By: Patrick L. McGillan   July, 1987                 */
  48. /*                                                         */
  49. /*    -------------------------------------------------    */
  50. /*                                                         */
  51. /*    Modified to allow multiple cross refrenced           */
  52. /*    files on the command lines.                          */
  53. /*                                                         */
  54. /*    By: Patrick L. McGillan    Nov, 1990                 */
  55. /*                                                         */
  56. /*    -------------------------------------------------    */
  57. /*                                                         */
  58. /*    Please report bugs/fixes/enhancements to:            */
  59. /*                                                         */
  60. /*            Philip N. Hisley                             */
  61. /*            548H Jamestown Court                         */
  62. /*            Edgewood, Maryland 21040                     */
  63. /*            (301) 679-4606                               */
  64. /*            Net Addr: PNH@MIT-AI                         */
  65. /*                                                         */
  66. /*                                                         */
  67. /***********************************************************/
  68.  
  69. #include "stdio.h"
  70. #include "ctype.h"
  71.  
  72. #define TRUE 1
  73. #define FALSE 0
  74. #define ERROR -1
  75. #define CPMEOF 0x1a
  76. #define MAX_REF    5           /* maximum refs per ref-block */
  77. #define MAX_LEN    20          /* maximum identifier length  */
  78. #define MAX_WRD  1000          /* maximum number of identifiers */
  79. #define MAX_ALPHA  53          /* maximum alpha chain heads */
  80. #define REFS_PER_LINE  8       /* maximum refs per line */
  81. #define LINES_PER_PAGE 60
  82. #define FF 0x0C                 /* formfeed */
  83.  
  84. struct  rf_blk {
  85.         int  ref_item[MAX_REF];
  86.         int  ref_cnt;
  87. } 
  88. onerf;
  89.  
  90. struct  id_blk {
  91.         char  id_name[MAX_LEN];
  92.         struct id_blk *alpha_lnk;
  93.         struct rf_blk *top_lnk;
  94.         struct rf_blk *lst_lnk;
  95. } 
  96. oneid;
  97.  
  98. struct id_blk *id_vector[MAX_WRD];
  99.  
  100. struct alpha_hdr { 
  101.         struct id_blk *alpha_top;
  102.         struct id_blk *alpha_lst;
  103. };
  104.  
  105. struct alpha_hdr alpha_vector[MAX_ALPHA];
  106.  
  107. int     linum;          /* line number                  */
  108. int     edtnum;         /* edit line number             */
  109. int     fil_cnt;        /* active file index            */
  110. int     wrd_cnt;        /* token count                  */
  111. int     pagno;          /* page number                  */
  112. int     id_cnt;         /* number of unique identifiers */
  113. int     rhsh_cnt;       /* number of conflict hits      */
  114. int     filevl;         /* file level                   */
  115. int     paglin;         /* page line counter            */
  116. int     paglen;         /* length of a page             */
  117. int     prt_ref;
  118. char    act_fil[MAX_LEN];
  119. char    lst_fil[MAX_LEN];
  120. char    gbl_fil[MAX_LEN];
  121. FILE    *l_buffer;
  122.  
  123. int     i_flg,o_flg,r_flg,l_flg,c_flg;
  124.  
  125. main (argc,argv)
  126. int     argc;
  127. char    *argv[];
  128.  
  129. {
  130.         char  flag;
  131.         register int carg;
  132.  
  133.         if (argc < 2) use_err();
  134.  
  135.         c_flg = i_flg = r_flg = o_flg = l_flg = FALSE;
  136.  
  137.         for (carg = 1; carg < argc; ++carg) {
  138.                 if (argv[carg][0] == '-') {     /* if its a switch, process it */
  139.                         switch (argv[carg][1]) {
  140.                                 case 'c':
  141.                                 case 'C': c_flg++;
  142.                                           break;
  143.                                 case 'i':
  144.                                 case 'I': i_flg++;
  145.                                           break;
  146.                                 case 'l':
  147.                                 case 'L': l_flg++;
  148.                                           break;
  149.                                 case 'o': 
  150.                                 case 'O': o_flg++;
  151.                                           if (argv[carg][2] == 0) use_err();
  152.                                           strcpy (lst_fil, &argv[carg][2]);
  153.                                           break;
  154.                                 case 'p':
  155.                                 case 'P': strcpy (act_fil, &argv[carg][2]);
  156.                                           paglen = atoi(act_fil);
  157.                                           break;
  158.                                 case 'r':
  159.                                 case 'R': r_flg++;
  160.                                           break;
  161.                                 default : use_err();
  162.                         }
  163.                 } else break;
  164.         }
  165.  
  166.         if (paglen < 10) paglen = LINES_PER_PAGE;
  167.  
  168.         if (!o_flg) {
  169.                 o_flg++;
  170.                 strcpy (lst_fil, "a.crf");
  171.         }
  172.  
  173.         if (o_flg) {
  174.                 if ((l_buffer=fopen(lst_fil,"w"))==NULL) { 
  175.                         printf("ERROR: Unable to create list file - %s\n",lst_fil);
  176.                         exit(0);
  177.                 }
  178.                 printf ("\n\nCROSS ... 'C' Cross Reference Utility  v1.0\n\n");
  179.                 printf ("Output is in file: %s\n\n", lst_fil);
  180.         }
  181.  
  182.         prt_ref = FALSE;
  183.  
  184.         for(linum=0;linum < MAX_WRD;linum++) {
  185.                 id_vector[linum] = NULL; 
  186.         }
  187.  
  188.         for(linum=0;linum < MAX_ALPHA;linum++)
  189.                 alpha_vector[linum].alpha_top = alpha_vector[linum].alpha_lst = NULL;
  190.  
  191.         fil_cnt = wrd_cnt = 0;
  192.  
  193.         filevl = paglin = pagno = 0;
  194.  
  195.         if (c_flg) linum = edtnum = 1;
  196.         else linum = edtnum = 0;
  197.  
  198.         id_cnt = rhsh_cnt = 0;
  199.  
  200.         do {
  201.             strcpy (gbl_fil, argv[carg]);
  202.             proc_file (gbl_fil);
  203.         } while (++carg<argc);
  204.  
  205.         if (!l_flg) {
  206.                 prnt_tbl ();
  207.                 printf ("\nAllowable Symbols: %d\n",MAX_WRD);
  208.                 printf ("Unique    Symbols: %d\n",id_cnt);
  209.         }
  210.  
  211.         if (o_flg) {
  212.                 nl ();
  213.                 fprintf (l_buffer,"%c",CPMEOF);
  214.                 fflush (l_buffer);
  215.                 fclose (l_buffer);
  216.         }
  217. }
  218.  
  219.  
  220.  
  221. use_err()
  222. { 
  223.         printf("\n\n\007");
  224.         printf("Usage: cross <flag(s)> <filename>\n\n");
  225.         printf("Flags: -i            = Enable file inclusion\n");
  226.         printf("       -c            = Cross reference only\n");
  227.         printf("       -l            = Generate listing only\n");
  228.         printf("       -o<filename>  = Write output to named file\n");
  229.         printf("       -p<n>         = Change length of page (Def:60)\n");
  230.         printf("       -r            = Cross-reference reserved words\n");
  231.         exit(0); 
  232. }
  233.  
  234. proc_file(filnam)
  235. char    *filnam;
  236. {
  237.         FILE  *buffer;        /* allocated buffer pointer */
  238.         char  token[MAX_LEN]; /* token buffer */
  239.         int   eof_flg;        /* end-of-file indicator */
  240.         int   tok_len;        /* token length */
  241.         int   incnum;         /* included line number */
  242.         strcpy(act_fil,filnam);
  243.         if((buffer=fopen(filnam,"r"))==NULL)
  244.         {
  245.                 printf ("\nERROR: Unable to open input file: %s\n",filnam);
  246.                 fprintf (l_buffer, "\nERROR: Unable to open input file: %s",filnam);
  247.                 if (incnum)
  248.                         return;
  249.                 exit(0);
  250.         }
  251.         if ((filevl++ == 0) && (!c_flg))
  252.                 prt_hdr();
  253.         eof_flg = FALSE;
  254.         do { 
  255.                 if(get_token(buffer,token,&tok_len,&eof_flg,0))
  256.                         if(chk_token(token))
  257.                         {
  258.                                 if(strcmp(token,"#include") == 0) 
  259.                                         if(get_token(buffer,token,&tok_len,&eof_flg,1))
  260.                                                 if(!i_flg) continue;
  261.                                 else
  262.                                     { 
  263.                                         incnum=edtnum;
  264.                                         edtnum=0;
  265.                                         if (!c_flg)
  266.                                                 nl();
  267.                                         proc_file(token); 
  268.                                         edtnum=incnum;
  269.                                         strcpy(act_fil,filnam);
  270.                                         continue;
  271.                                 }
  272.                                 put_token(token,linum);
  273.                         }
  274.         } 
  275.         while (!eof_flg);
  276.  
  277.         filevl -= 1;
  278.         fclose(buffer);
  279. }
  280.  
  281. get_token(g_buffer,g_token,g_toklen,g_eoflg,g_flg)
  282.  
  283. FILE    *g_buffer;
  284. char    *g_token;
  285. int     *g_toklen;
  286. int     *g_eoflg;
  287. int     g_flg;
  288.  
  289. /*
  290.         'getoken' returns the next valid identifier or
  291.         reserved word from a given file along with the
  292.         character length of the token and an end-of-file
  293.         indicator
  294. */
  295.  
  296. {
  297.         int     c;
  298.         char    *h_token;
  299.         char    tmpchr;
  300.  
  301.         h_token = g_token;
  302.  
  303. gtk:
  304.         *g_toklen = 0;
  305.         g_token = h_token;
  306.  
  307.         /* Scan and discard any characters until an alphabetic or
  308.            '_' (underscore) character is encountered or an end-of-file
  309.            condition occurs        */
  310.  
  311.         while((!isalpha(*g_token = rdchr(g_buffer,g_eoflg,g_flg))) && !*g_eoflg
  312.             && *g_token != '_' && *g_token != '0' && *g_token != '#');
  313.         if(*g_eoflg) return(FALSE);
  314.         *g_toklen += 1;
  315.  
  316.         /*    Scan and collect identified alpanumeric token until
  317.               a non-alphanumeric character is encountered or and
  318.               end-of-file condition occurs              */
  319.  
  320.         if(g_flg) tmpchr = '.';
  321.         else tmpchr = '_';
  322.         while((isalpha(c=rdchr(g_buffer,g_eoflg,g_flg)) ||
  323.             isdigit(c) || c == '_' || c == tmpchr) && !*g_eoflg)
  324.         { 
  325.                 if(*g_toklen < MAX_LEN)
  326.                 { 
  327.                         *++g_token = c;
  328.                         *g_toklen += 1; 
  329.                 }
  330.         }
  331.  
  332.         /*   Check to see if a numeric hex or octal constant has
  333.              been encountered ... if so dump it and try again     */
  334.  
  335.         if (*h_token == '0') goto gtk;
  336.  
  337.  
  338.         /*
  339.                                 Tack a NULL character onto the end of the token
  340.                         */
  341.  
  342.         *++g_token = NULL;
  343.  
  344.         /*
  345.                                 Screen out all #token strings except #include
  346.                         */
  347.  
  348.         if (*h_token == '#' && strcmp(h_token,"#include")) goto gtk;
  349.  
  350.         return(TRUE);
  351. }
  352.  
  353. fil_chr(f_buffer,f_eof)
  354. FILE *f_buffer;
  355. int *f_eof;
  356. { 
  357.         int fc;
  358.         fc=getc(f_buffer);
  359.         if (fc == CPMEOF || fc == EOF) { 
  360.                 *f_eof = TRUE;
  361.                 fc = NULL; 
  362.         }
  363.         return(fc);
  364. }
  365.  
  366. /***************************************************************************
  367.  *       'rdchr' returns the next valid character in a file
  368.  *       and an end-of-file indicator. A valid character is
  369.  *       defined as any which does not appear in either a
  370.  *       commented or a quoted string ... 'rdchr' will correctly
  371.  *       handle comment tokens which appear within a quoted
  372.  *       string
  373.  */
  374.  
  375. rdchr(r_buffer,r_eoflg,rd_flg)
  376. int     *r_eoflg;
  377. FILE    *r_buffer;
  378. int     rd_flg;
  379. {
  380.         int     c;
  381.         int     q_flg;          /* double quoted string flag */
  382.         int     q1_flg;         /* single quoted string flag */
  383.         int     cs_flg;         /* comment start flag */
  384.         int     ce_flg;         /* comment end flag */
  385.         int     c_cnt;          /* comment nesting level */
  386.         int     t_flg;          /* transparency flag */
  387.  
  388.         q_flg = FALSE;
  389.         q1_flg = FALSE;
  390.         cs_flg = FALSE;
  391.         ce_flg = FALSE;
  392.         t_flg = FALSE;
  393.         c_cnt  = 0;
  394. rch:    c=fil_chr(r_buffer,r_eoflg);            /* Fetch character from file */
  395.         if(*r_eoflg)                            /* EOF encountered */
  396.                 return(c);
  397.         if (c == '\n')
  398.                 if (!c_flg)
  399.                         nl();
  400.                 else
  401.                 {
  402.                         ++linum;
  403.                         ++edtnum;
  404.                 }
  405.         else
  406.                 if (!c_flg)
  407.                         if(o_flg)
  408.                                 fprintf(l_buffer,"%c",c);
  409.                         else
  410.                                 printf("%c",c);
  411.         if(rd_flg)
  412.                 return(c);
  413.         if(t_flg)
  414.         { 
  415.                 t_flg = !t_flg;
  416.                 goto rch;
  417.         }
  418.         if(c == '\\')
  419.         {
  420.                 t_flg = TRUE;
  421.                 goto rch;
  422.         }
  423.         /* 
  424.                                 If the character is not part of a quoted string
  425.                                 check for and process commented strings...
  426.                                 nested comments are handled correctly but unbalanced
  427.                                 comments are not ... the assumption is made that
  428.                                 the syntax of the program being xref'd is correct
  429.                         */
  430.  
  431.         if (!q_flg && !q1_flg) {
  432.                 if (c == '*' && c_cnt && !cs_flg) { 
  433.                         ce_flg = TRUE;
  434.                         goto rch;
  435.                 }
  436.                 if (c == '/' && ce_flg) { 
  437.                         c_cnt -= 1;
  438.                         ce_flg = FALSE;
  439.                         goto rch; 
  440.                 }
  441.                 ce_flg = FALSE;
  442.                 if (c == '/') { 
  443.                         cs_flg = TRUE;
  444.                         goto rch; 
  445.                 }
  446.                 if (c == '*' && cs_flg) { 
  447.                         c_cnt += 1;
  448.                         cs_flg = FALSE;
  449.                         goto rch; 
  450.                 }
  451.                 cs_flg = FALSE;
  452.                 if (c_cnt) goto rch;
  453.         }
  454.  
  455.         /*
  456.                                 Check for and process quoted strings
  457.                         */
  458.  
  459.         if ( c == '"' && !q1_flg) { 
  460.                 q_flg =  !q_flg; /* toggle quote flag */
  461.                 goto rch;
  462.         }
  463.         if (q_flg) goto rch;
  464.  
  465.         if (c == '\'') { 
  466.                 q1_flg = !q1_flg; /* toggle quote flag */
  467.                 goto rch; 
  468.         }
  469.         if (q1_flg) goto rch;
  470.  
  471.         /*
  472.                                 Valid character ... return to caller
  473.                         */
  474.  
  475.         return(c);
  476. }
  477.  
  478. chk_token(c_token)
  479. char    *c_token;
  480.  
  481. {
  482.         char  u_token[MAX_LEN];
  483.         int   i;
  484.  
  485.         {
  486.                 if(r_flg) return(TRUE);
  487.                 i = 0;
  488.                 do { 
  489.                         u_token[i] = toupper(c_token[i]); 
  490.                 }
  491.                 while (c_token[i++] != NULL);
  492.  
  493.                 switch(u_token[0]) {
  494.                 case 'A': 
  495.                         if (strcmp(u_token,"AUTO") == 0) return(FALSE);
  496.                         break;
  497.                 case 'B': 
  498.                         if (strcmp(u_token,"BREAK") == 0) return(FALSE);
  499.                         break;
  500.                 case 'C': 
  501.                         if (strcmp(u_token,"CHAR") == 0) return (FALSE);
  502.                         if (strcmp(u_token,"CONTINUE") == 0) return (FALSE);
  503.                         if (strcmp(u_token,"CASE") == 0) return (FALSE);
  504.                         break;
  505.                 case 'D': 
  506.                         if(strcmp(u_token,"DOUBLE") == 0) return(FALSE);
  507.                         if(strcmp(u_token,"DO") == 0) return(FALSE);
  508.                         if(strcmp(u_token,"DEFAULT") == 0) return(FALSE);
  509.                         break;
  510.                 case 'E': 
  511.                         if(strcmp(u_token,"EXTERN") == 0) return(FALSE);
  512.                         if(strcmp(u_token,"ELSE") == 0) return(FALSE);
  513.                         if(strcmp(u_token,"ENTRY") == 0) return(FALSE);
  514.                         break;
  515.                 case 'F': 
  516.                         if(strcmp(u_token,"FLOAT") == 0) return(FALSE);
  517.                         if(strcmp(u_token,"FOR") == 0) return(FALSE);
  518.                         break;
  519.                 case 'G': 
  520.                         if(strcmp(u_token,"GOTO") == 0) return(FALSE);
  521.                         break;
  522.                 case 'I': 
  523.                         if(strcmp(u_token,"INT") == 0) return(FALSE);
  524.                         if(strcmp(u_token,"IF") == 0) return(FALSE);
  525.                         break;
  526.                 case 'L': 
  527.                         if(strcmp(u_token,"LONG") == 0) return(FALSE);
  528.                         break;
  529.                 case 'R': 
  530.                         if(strcmp(u_token,"RETURN") == 0) return(FALSE);
  531.                         if(strcmp(u_token,"REGISTER") == 0) return(FALSE);
  532.                         break;
  533.                 case 'S': 
  534.                         if(strcmp(u_token,"STRUCT") == 0) return(FALSE);
  535.                         if(strcmp(u_token,"SHORT") == 0) return(FALSE);
  536.                         if(strcmp(u_token,"STATIC") == 0) return(FALSE);
  537.                         if(strcmp(u_token,"SIZEOF") == 0) return(FALSE);
  538.                         if(strcmp(u_token,"SWITCH") == 0) return(FALSE);
  539.                         break;
  540.                 case 'T': 
  541.                         if(strcmp(u_token,"TYPEDEF") == 0) return(FALSE);
  542.                         break;
  543.                 case 'U': 
  544.                         if(strcmp(u_token,"UNION") == 0) return(FALSE);
  545.                         if(strcmp(u_token,"UNSIGNED") == 0) return(FALSE);
  546.                         break;
  547.                 case 'W': 
  548.                         if(strcmp(u_token,"WHILE") == 0) return(FALSE);
  549.                         break; 
  550.                 }
  551.         }
  552.         return(TRUE);
  553. }
  554.  
  555. /*
  556.    Install parsed token and line reference in linked structure
  557. */
  558.  
  559. put_token(p_token,p_ref)
  560.  
  561. char *p_token;
  562. int  p_ref;
  563.  
  564. {
  565.         int  hsh_index;
  566.         int  i;
  567.         int  j;
  568.         int  d;
  569.         int  found;
  570.         struct id_blk *idptr;
  571.         struct rf_blk *rfptr;
  572.         struct id_blk *alloc_id();
  573.         struct rf_blk *alloc_rf();
  574.         struct rf_blk *add_rf();
  575.  
  576.         if(l_flg) return;
  577.         j=0;
  578.         for (i=0; p_token[i] != NULL; i++)  /* Hashing algorithm is far from */
  579.         {                                   /* optimal but is adequate for a */
  580.                 j = j * 10 + p_token[i];        /* memory-bound index vector!    */
  581.         }
  582.         hsh_index = abs(j) % MAX_WRD;
  583.         found = FALSE;
  584.         d = 1;
  585.         do {
  586.                 idptr = id_vector[hsh_index];
  587.                 if(idptr == NULL) {
  588.                         id_cnt++;
  589.                         idptr = id_vector[hsh_index] = alloc_id(p_token);
  590.                         chain_alpha(idptr,p_token);
  591.                         idptr->top_lnk = idptr->lst_lnk = alloc_rf(p_ref);
  592.                         found = TRUE;
  593.                 }
  594.                 else
  595.                     if(strcmp(p_token,idptr->id_name) == 0) {
  596.                         idptr->lst_lnk = add_rf(idptr->lst_lnk,p_ref);
  597.                         found = TRUE;
  598.                 }
  599.                 else
  600.                     { 
  601.                         hsh_index += d;
  602.                         d += 2;
  603.                         rhsh_cnt++;
  604.                         if (hsh_index >= MAX_WRD)
  605.                                 hsh_index -= MAX_WRD;
  606.                         if (d == MAX_WRD) {
  607.                                 printf("\nERROR: Symbol table overflow\n");
  608.                                 exit(0);
  609.                         }
  610.                 }
  611.         } 
  612.         while (!found);
  613. }
  614.  
  615. chain_alpha(ca_ptr,ca_token)
  616.  
  617. struct id_blk *ca_ptr;
  618. char  *ca_token;
  619.  
  620. {
  621.         char  c;
  622.         int   f;
  623.         struct id_blk *cur_ptr;
  624.         struct id_blk *lst_ptr;
  625.  
  626.         c = ca_token[0];
  627.         if(c == '_') c = 0;
  628.         else
  629.                 isupper(c) ? (c=1+((c-'A')*2)) : (c=2+((c-'a')*2));
  630.  
  631.         if(alpha_vector[c].alpha_top == NULL)
  632.         { 
  633.                 alpha_vector[c].alpha_top =
  634.                     alpha_vector[c].alpha_lst = ca_ptr;
  635.                 ca_ptr->alpha_lnk = NULL;
  636.                 return;
  637.         }
  638.  
  639.         /* check to see if new id_blk should be inserted between
  640.                            the alpha_vector header block and the first id_blk in
  641.                            the current alpha chain
  642.                         */
  643.  
  644.         if(strcmp(alpha_vector[c].alpha_top->id_name,ca_token) >0)
  645.         {
  646.                 ca_ptr->alpha_lnk=alpha_vector[c].alpha_top;
  647.                 alpha_vector[c].alpha_top=ca_ptr;
  648.                 return;
  649.         }
  650.  
  651.         if(strcmp(alpha_vector[c].alpha_lst->id_name,ca_token) < 0)
  652.         { 
  653.                 alpha_vector[c].alpha_lst->alpha_lnk = ca_ptr;
  654.                 ca_ptr->alpha_lnk = NULL;
  655.                 alpha_vector[c].alpha_lst=ca_ptr;
  656.                 return;
  657.         }
  658.  
  659.         cur_ptr = alpha_vector[c].alpha_top;
  660.         while(strcmp(cur_ptr->id_name,ca_token) < 0)
  661.         { 
  662.                 lst_ptr = cur_ptr;
  663.                 cur_ptr = lst_ptr->alpha_lnk;
  664.         }
  665.  
  666.         lst_ptr->alpha_lnk = ca_ptr;
  667.         ca_ptr->alpha_lnk = cur_ptr;
  668.         return;
  669. }
  670.  
  671. struct id_blk *alloc_id(aid_token)
  672. char  *aid_token;
  673.  
  674. {
  675.         int  ai;
  676.         struct id_blk *aid_ptr;
  677.  
  678.         if((aid_ptr = malloc(sizeof(oneid))) == 0)
  679.         {
  680.                 printf("\nERROR: Out of user memory\n");
  681.                 exit(0);
  682.         }
  683.         ai=0;
  684.         do {
  685.                 aid_ptr->id_name[ai] = aid_token[ai];
  686.         } 
  687.         while (aid_token[ai++] != NULL);
  688.         return (aid_ptr);
  689. }
  690.  
  691. struct rf_blk *alloc_rf(arf_ref)
  692.  
  693. int  arf_ref;
  694.  
  695. {
  696.         int ri;
  697.         struct rf_blk *arf_ptr;
  698.  
  699.         if((arf_ptr = malloc(sizeof(onerf))) == 0)
  700.         {
  701.                 printf("\nERROR: Out of user memory\n");
  702.                 exit(0);
  703.         }
  704.         arf_ptr->ref_item[0] = arf_ref;
  705.         arf_ptr->ref_cnt = 1;
  706.         for(ri=1;ri<MAX_REF;ri++)
  707.                 arf_ptr->ref_item[ri] = NULL;
  708.         return (arf_ptr);
  709. }
  710.  
  711. struct rf_blk *add_rf(adr_ptr,adr_ref)
  712.  
  713. struct rf_blk *adr_ptr;
  714. int adr_ref;
  715.  
  716. {
  717.         struct rf_blk *tmp_ptr;
  718.  
  719.         tmp_ptr = adr_ptr;
  720.         if(adr_ptr->ref_cnt == MAX_REF) {
  721.                 tmp_ptr = adr_ptr->ref_cnt = alloc_rf(adr_ref);
  722.         }
  723.         else
  724.             { 
  725.                 adr_ptr->ref_item[adr_ptr->ref_cnt++] = adr_ref;
  726.         }
  727.         return (tmp_ptr);
  728. }
  729.  
  730. prnt_tbl()
  731. {  
  732.         int prf_cnt;
  733.         int pti;
  734.         int pref;
  735.         int lin_cnt;
  736.         struct id_blk *pid_ptr;
  737.         struct rf_blk *ptb_ptr;
  738.  
  739.         prt_ref = TRUE;
  740.         prt_hdr();
  741.         for (pti=0;pti<MAX_ALPHA;pti++)
  742.         { 
  743.                 if ((pid_ptr = alpha_vector[pti].alpha_top) != NULL)
  744.                 { 
  745.                         do
  746.                             { 
  747.                                 if(o_flg)
  748.                                 {
  749.                                         fprintf(l_buffer,"%-14.13s: ",pid_ptr->id_name);
  750.                                 }
  751.                                 else
  752.                                     printf("%-14.13s: ",pid_ptr->id_name);
  753.                                 ptb_ptr=pid_ptr->top_lnk;
  754.                                 lin_cnt=prf_cnt=0;
  755.                                 do { 
  756.                                         if(prf_cnt == MAX_REF)
  757.                                         { 
  758.                                                 prf_cnt=0;
  759.                                                 ptb_ptr = ptb_ptr->ref_cnt;
  760.                                         }
  761.                                         if(ptb_ptr > MAX_REF)
  762.                                         {
  763.                                                 if((pref=ptb_ptr->ref_item[prf_cnt++]) != 0)
  764.                                                 { 
  765.                                                         if(o_flg)
  766.                                                         {
  767.                                                                 fprintf(l_buffer,"%d\t",pref);
  768.                                                         }
  769.                                                         else
  770.                                                             printf("%d\t",pref);
  771.                                                         if (++lin_cnt == REFS_PER_LINE)
  772.                                                         { 
  773.                                                                 nl();
  774.                                                                 if(o_flg)
  775.                                                                 {
  776.                                                                         fprintf(l_buffer,"\t\t");
  777.                                                                 }
  778.                                                                 else
  779.                                                                     printf("\t\t");
  780.                                                                 lin_cnt=0;
  781.                                                         }
  782.                                                 }
  783.                                         } 
  784.                                         else pref=0;
  785.                                 } 
  786.                                 while (pref);
  787.                                 if (lin_cnt = 0)
  788.                                         nl();
  789.                                 else
  790.                                 { 
  791.                                         nl(); 
  792.                                         nl(); 
  793.                                 }
  794.                         } 
  795.                         while ((pid_ptr=pid_ptr->alpha_lnk) != NULL);
  796.                 }
  797.         }
  798. }
  799.  
  800. prt_hdr()
  801.  
  802. { 
  803.         if (pagno++ != 0)
  804.                 if (o_flg)
  805.                         fprintf(l_buffer,"%c",FF);
  806.                 else
  807.                         printf("%c",FF);
  808.         if (o_flg)
  809.                 fprintf (l_buffer, "'C' Cross Reference Utility  -  File: %s\t\t\t\t Page %d", gbl_fil, pagno);
  810.         else
  811.                 printf ("'C' Cross Reference Utility  -  File: %s\t\t\t\t Page %d", gbl_fil, pagno);
  812.         if (o_flg)
  813.                 fprintf(l_buffer,"\n\n");
  814.         else
  815.                 printf("\n\n");
  816.         if (!c_flg)
  817.                 nl();
  818.         paglin =3;
  819.         return;
  820. }
  821.  
  822.  
  823. /***************************************************************************
  824.  * do end of input file line stuff
  825.  */
  826.  
  827. nl()
  828. { 
  829.         if (o_flg)
  830.                 fprintf(l_buffer,"\n");
  831.         else
  832.                 printf("\n");
  833.         if (++paglin == paglen)
  834.                 prt_hdr();
  835.         else
  836.                 if (!prt_ref)
  837.                 {
  838.                         if (o_flg)
  839.                                 fprintf(l_buffer,"%-4.4d.%4.4d:\t",++linum,++edtnum);
  840.                         else
  841.                                 printf("%-4.4d.%4.4d:\t",++linum,++edtnum);
  842.                         if (o_flg) 
  843.                                 if(linum % 60 == 1) 
  844.                                         printf("\n<%d>\t",linum);
  845.                         else
  846.                             printf(".");
  847.                 }
  848.         return;
  849. }
  850.  
  851.  
  852. /*      atoi:   ascii string to integer
  853.  * This is too inconsistant to use the system's
  854.  */
  855.  
  856. atoi(st)
  857.  
  858. char *st;
  859.  
  860. {
  861.         int result;     /* resulting number */
  862.         int sign;       /* sign of resulting number */
  863.         char c;         /* current char being examined */
  864.  
  865.         result = 0;
  866.         sign = 1;
  867.  
  868.         /* skip preceding whitespace */
  869.         while (*st == ' ' || *st == '\t')
  870.                 ++st;
  871.  
  872.         /* check for sign */
  873.         if (*st == '-') {
  874.                 sign = -1;
  875.                 ++st;
  876.         }
  877.         if (*st == '+')
  878.                 ++st;
  879.  
  880.         /* scan digits, build value */
  881.         while ((c = *st++))
  882.                 if (c >= '0' && c <= '9')
  883.                         result = result * 10 + c - '0';
  884.                 else
  885.                         return(0);
  886.  
  887.         return(result * sign);
  888. }
  889.